home *** CD-ROM | disk | FTP | other *** search
/ Usenet 1993 July / InfoMagic USENET CD-ROM July 1993.ISO / sources / x / volume19 / xview-1.0 / patch01 next >
Encoding:
Text File  |  1993-04-28  |  8.9 KB  |  374 lines
  1. Newsgroups: comp.sources.x
  2. From: Norbert Jung <jung@dia.informatik.uni-stuttgart.de>
  3. Subject: v19i002:  xview-1.0 - cute GO'ish game, Patch01
  4. Message-ID: <1993Mar4.231322.16030@sparky.imd.sterling.com>
  5. X-Md4-Signature: 905c84e047c6f7e9ba3b4b4a6310ea1c
  6. Date: Thu, 4 Mar 1993 23:13:22 GMT
  7. Approved: chris@sparky.imd.sterling.com
  8.  
  9. Submitted-by: Norbert Jung <jung@dia.informatik.uni-stuttgart.de>
  10. Posting-number: Volume 19, Issue 2
  11. Archive-name: xview-1.0/patch01
  12. Environment: X11
  13. Patch-To: xvier-1.0: Volume 18, Issue 57-58
  14.  
  15.  
  16. Now there is support for 88open certified systems, contributed by Jo
  17. Stockley, and some speedups (full alpha-beta-window search for deep
  18. cut-offs)
  19.  
  20. Thanks,
  21.     Norbert Jung
  22.  
  23. diff -cr xvier-1.0/patchlevel.h xvier-1.1/patchlevel.h
  24. *** xvier-1.0/patchlevel.h    Fri Apr 10 12:57:54 1992
  25. --- xvier-1.1/patchlevel.h    Fri Jul 31 12:41:55 1992
  26. ***************
  27. *** 1 ****
  28. ! #define XVIER_VERSION "xvier Version 1.0"
  29. --- 1 ----
  30. ! #define XVIER_VERSION "xvier Version 1.1"
  31. diff -cr xvier-1.0/vier.c xvier-1.1/vier.c
  32. *** xvier-1.0/vier.c    Tue Apr 21 10:54:28 1992
  33. --- xvier-1.1/vier.c    Fri Jul 31 12:41:56 1992
  34. ***************
  35. *** 311,334 ****
  36.     }
  37.   }
  38.   
  39. ! int comp_weiss(pos, lev, limit)
  40. ! int pos, lev, limit;
  41.   {
  42. !   register int  h1, h2, i, j, *p;
  43. !   int   *frp, wert;
  44. !   struct oldv *sold;
  45.   
  46.     if (brett[pos] & W_WINS)
  47.       return 50000 - lev;
  48.     /* Zug fuer Weiss ausfuehren */
  49.     sold = sp;
  50. !   sp -> pos = frp = freip[pos];
  51. !   sp++ -> value = *frp;
  52.     sp -> pos = brett + pos;
  53.     sp++ -> value = brett[pos];
  54.     sp -> pos = &bewertung;
  55.     sp++ -> value = bewertung;
  56. !   *frp += columns;
  57.     brett[pos] |= WEISS;
  58.     p = pp[pos];
  59.     while ((h1 = *(p++)) >= 0) {
  60. --- 311,333 ----
  61.     }
  62.   }
  63.   
  64. ! int comp_weiss(pos, lev, alpha, beta)
  65. ! int pos, lev, alpha, beta;
  66.   {
  67. !   register int h1, h2, i, j, *p;
  68. !   register struct oldv *sold;
  69.   
  70.     if (brett[pos] & W_WINS)
  71.       return 50000 - lev;
  72.     /* Zug fuer Weiss ausfuehren */
  73.     sold = sp;
  74. !   sp -> pos = p = freip[pos];
  75. !   sp++ -> value = *p;
  76.     sp -> pos = brett + pos;
  77.     sp++ -> value = brett[pos];
  78.     sp -> pos = &bewertung;
  79.     sp++ -> value = bewertung;
  80. !   *p += columns;
  81.     brett[pos] |= WEISS;
  82.     p = pp[pos];
  83.     while ((h1 = *(p++)) >= 0) {
  84. ***************
  85. *** 347,359 ****
  86.         bewertung += h2;
  87.       }
  88.     }
  89. !   h1 = -1;
  90.     for (i = 0; i < columns; i++) {
  91.       register int f = frei[i];
  92.   
  93.       if (f < row_col) {
  94.         if (brett[f] & S_WINS) {
  95. !     wert = -49999 + lev;
  96.       goto end;
  97.         }
  98.         if (brett[f] & W_WINS)
  99. --- 346,359 ----
  100.         bewertung += h2;
  101.       }
  102.     }
  103. !   h2 = h1 = -1;
  104.     for (i = 0; i < columns; i++) {
  105.       register int f = frei[i];
  106.   
  107.       if (f < row_col) {
  108. +       h2 = 0;
  109.         if (brett[f] & S_WINS) {
  110. !     beta = -49999 + lev;
  111.       goto end;
  112.         }
  113.         if (brett[f] & W_WINS)
  114. ***************
  115. *** 360,385 ****
  116.       h1 = f;
  117.       }
  118.     }
  119.     if (h1 >= 0) {
  120.       level++;
  121. !     wert = comp_schwarz(h1, lev + 1, 100000);
  122.       level--;
  123.     } else if (lev >= level)
  124. !     wert = bewertung + s_zugzwang(40 - lev - zugstackp);
  125.     else {
  126.       register int    zw;
  127.   
  128. -     wert = 100000;
  129.       for (i = 0; i < columns; i++) {
  130.         j = frei[reihenfolge[i]];
  131.         if (j < row_col)
  132. !     if ((zw = comp_schwarz (j, lev + 1, wert)) < wert)
  133. !       if ((wert = zw) <= limit)
  134.           break;
  135.         /* Schwarz wird wohl den fuer ihn guenstigsten Zug auswaehlen */
  136.       }
  137. -     if (wert == 100000)
  138. -       wert = 0;        /* unentschieden */
  139.     }
  140.    end:
  141.     while (sp != sold) {
  142. --- 360,386 ----
  143.       h1 = f;
  144.       }
  145.     }
  146. +   if (h2 < 0) {
  147. +     beta = 0;    /* unentschieden */
  148. +     goto end;
  149. +   }
  150.     if (h1 >= 0) {
  151.       level++;
  152. !     beta = comp_schwarz(h1, lev + 1, alpha, beta);
  153.       level--;
  154.     } else if (lev >= level)
  155. !     beta = bewertung + s_zugzwang(40 - lev - zugstackp);
  156.     else {
  157.       register int    zw;
  158.   
  159.       for (i = 0; i < columns; i++) {
  160.         j = frei[reihenfolge[i]];
  161.         if (j < row_col)
  162. !     if ((zw = comp_schwarz (j, lev + 1, alpha, beta)) < beta)
  163. !       if ((beta = zw) <= alpha)
  164.           break;
  165.         /* Schwarz wird wohl den fuer ihn guenstigsten Zug auswaehlen */
  166.       }
  167.     }
  168.    end:
  169.     while (sp != sold) {
  170. ***************
  171. *** 386,412 ****
  172.       sp--;
  173.       *(sp -> pos) = sp -> value;
  174.     }
  175. !   return (wert);
  176.   }
  177.   
  178. ! int comp_schwarz(pos, lev, limit)
  179. ! int pos, lev, limit;
  180.   {
  181. !   register int  h1, h2, i, j, *p;
  182. !   int   *frp, wert;
  183. !   struct oldv *sold;
  184.   
  185.     if (brett[pos] & S_WINS)
  186.       return -50000 + lev;
  187.     /* Zug fuer Schwarz ausfuehren */
  188.     sold = sp;
  189. !   sp -> pos = frp = freip[pos];
  190. !   sp++ -> value = *frp;
  191.     sp -> pos = brett + pos;
  192.     sp++ -> value = brett[pos];
  193.     sp -> pos = &bewertung;
  194.     sp++ -> value = bewertung;
  195. !   *frp += columns;
  196.     brett[pos] |= SCHWARZ;
  197.     p = pp[pos];
  198.     while ((h1 = *(p++)) >= 0) {
  199. --- 387,412 ----
  200.       sp--;
  201.       *(sp -> pos) = sp -> value;
  202.     }
  203. !   return beta;
  204.   }
  205.   
  206. ! int comp_schwarz(pos, lev, alpha, beta)
  207. ! int pos, lev, alpha, beta;
  208.   {
  209. !   register int h1, h2, i, j, *p;
  210. !   register struct oldv *sold;
  211.   
  212.     if (brett[pos] & S_WINS)
  213.       return -50000 + lev;
  214.     /* Zug fuer Schwarz ausfuehren */
  215.     sold = sp;
  216. !   sp -> pos = p = freip[pos];
  217. !   sp++ -> value = *p;
  218.     sp -> pos = brett + pos;
  219.     sp++ -> value = brett[pos];
  220.     sp -> pos = &bewertung;
  221.     sp++ -> value = bewertung;
  222. !   *p += columns;
  223.     brett[pos] |= SCHWARZ;
  224.     p = pp[pos];
  225.     while ((h1 = *(p++)) >= 0) {
  226. ***************
  227. *** 425,437 ****
  228.         bewertung -= h2;
  229.       }
  230.     }
  231. !   h1 = -1;
  232.     for (i = 0; i < columns; i++) {
  233.       register int f = frei[i];
  234.   
  235.       if (f < row_col) {
  236.         if (brett[f] & W_WINS) {
  237. !     wert = 49999 - lev;
  238.       goto end;
  239.         }
  240.         if (brett[f] & S_WINS)
  241. --- 425,438 ----
  242.         bewertung -= h2;
  243.       }
  244.     }
  245. !   h2 = h1 = -1;
  246.     for (i = 0; i < columns; i++) {
  247.       register int f = frei[i];
  248.   
  249.       if (f < row_col) {
  250. +       h2 = 0;
  251.         if (brett[f] & W_WINS) {
  252. !     alpha = 49999 - lev;
  253.       goto end;
  254.         }
  255.         if (brett[f] & S_WINS)
  256. ***************
  257. *** 438,462 ****
  258.       h1 = f;
  259.       }
  260.     }
  261.     if (h1 >= 0) {
  262.       level++;
  263. !     wert = comp_weiss(h1, lev + 1, -100000);
  264.       level--;
  265.     } else if (lev >= level)
  266. !     wert = bewertung + w_zugzwang(40 - lev - zugstackp);
  267.     else {
  268.       register int    zw;
  269.   
  270. -     wert = -100000;
  271.       for (i = 0; i < columns; i++) {
  272.         j = frei[reihenfolge[i]];
  273.         if (j < row_col)
  274. !     if ((zw = comp_weiss (j, lev + 1, wert)) > wert)
  275. !       if ((wert = zw) >= limit)
  276.           break;
  277.       }
  278. -     if (wert == -100000)
  279. -       wert = 0;        /* unentschieden */
  280.     }
  281.    end:
  282.     while (sp != sold) {
  283. --- 439,464 ----
  284.       h1 = f;
  285.       }
  286.     }
  287. +   if (h2 < 0) {
  288. +     alpha = 0;    /* unentschieden */
  289. +     goto end;
  290. +   }
  291.     if (h1 >= 0) {
  292.       level++;
  293. !     alpha = comp_weiss(h1, lev + 1, alpha, beta);
  294.       level--;
  295.     } else if (lev >= level)
  296. !     alpha = bewertung + w_zugzwang(40 - lev - zugstackp);
  297.     else {
  298.       register int    zw;
  299.   
  300.       for (i = 0; i < columns; i++) {
  301.         j = frei[reihenfolge[i]];
  302.         if (j < row_col)
  303. !     if ((zw = comp_weiss (j, lev + 1, alpha, beta)) > alpha)
  304. !       if ((alpha = zw) >= beta)
  305.           break;
  306.       }
  307.     }
  308.    end:
  309.     while (sp != sold) {
  310. ***************
  311. *** 463,469 ****
  312.       sp--;
  313.       *(sp -> pos) = sp -> value;
  314.     }
  315. !   return (wert);
  316.   }
  317.   
  318.   int main(argc, argv)
  319. --- 465,471 ----
  320.       sp--;
  321.       *(sp -> pos) = sp -> value;
  322.     }
  323. !   return alpha;
  324.   }
  325.   
  326.   int main(argc, argv)
  327. ***************
  328. *** 565,571 ****
  329.         register int zw;
  330.         
  331.         if ((j = frei[reihenfolge[i]]) < row_col)
  332. !         if ((zw = comp_schwarz (j, 0, wert + 1)) < wert) {
  333.             wert = zw;
  334.             same_n = 1;
  335.             same[0] = reihenfolge[i];
  336. --- 567,573 ----
  337.         register int zw;
  338.         
  339.         if ((j = frei[reihenfolge[i]]) < row_col)
  340. !         if ((zw = comp_schwarz (j, 0, -100000, wert + 1)) < wert) {
  341.             wert = zw;
  342.             same_n = 1;
  343.             same[0] = reihenfolge[i];
  344. diff -cr xvier-1.0/xvier.h xvier-1.1/xvier.h
  345. *** xvier-1.0/xvier.h    Thu Apr  9 17:12:51 1992
  346. --- xvier-1.1/xvier.h    Fri Jul 31 12:41:56 1992
  347. ***************
  348. *** 8,10 ****
  349. --- 8,16 ----
  350.   #if defined(_IBMR2)
  351.   #define NO_FD_SET
  352.   #endif
  353. + 
  354. + /* changes from Jo Stockley (jo@88open.org) for 88open certified systems */
  355. + #if defined(m88k)
  356. + #define NO_GETDTABSIZE
  357. + #include <unistd.h>
  358. + #endif
  359.  
  360.  
  361. +----------------------------------------------------------------------------+
  362. |Norbert Jung               BITNET: jung%dia%ifistg@unido.bitnet             |
  363. |Student              local: jung@dia                                 |
  364. |Universitaet Stuttgart       SMTP: jung@dia.informatik.uni-stuttgart.de     |
  365. |BR Deutschland                  X400: jung@dia.informatik.uni-stuttgart.dbp.de |
  366. +----------------------------------------------------------------------------+
  367.  
  368. exit 0 # Just in case...
  369. -- 
  370.   // chris@IMD.Sterling.COM            | Send comp.sources.x submissions to:
  371. \X/  Amiga - The only way to fly!      |
  372.  "It's intuitively obvious to the most |    sources-x@imd.sterling.com
  373.   casual observer..."                  |
  374.